import logger from '../utils/logger.js'
function parse(tokens) {
  let pos = 0;

  function peek(offset = 0) {
    return tokens[pos + offset];
  }

  function consume(expected) {
    const t = tokens[pos];
    if (expected && t !== expected) {
      // 检查是否是中文标点符号导致的错误
      const chinesePunctuationMap = {
        '；': ';',  '，': ',',  '（': '(',  '）': ')',  '【': '[',  '】': ']',
        '｛': '{',  '｝': '}',  '《': '<',  '》': '>',  '：': ':',  '！': '!',
        '？': '?',  '＂': '"',  '＇': "'",  '＼': '\\', '｜': '|',  '＆': '&',
        '＠': '@',  '＃': '#',  '＄': '$',  '％': '%',  '＾': '^',  '～': '~',
        '｀': '`',  '－': '-',  '＝': '=',  '＋': '+',  '＊': '*',  '／': '/',
        '＜': '<',  '＞': '>',  '［': '[',  '］': ']'
      };
      
      if (chinesePunctuationMap[t]) {
        throw new Error(`检测到中文标点符号 "${t}"，请使用英文标点符号 "${chinesePunctuationMap[t]}"`);
      }
      
      throw new Error(`Expected '${expected}' but got '${t}'`);
    }
    pos++;
    return t;
  }

  /* 
   *解析表达式（1>0） 
   *返回运算符，左右值
  */
  function parseExpression() {
    return parseLogicalOrExpression();
  }

  function parseLogicalOrExpression() {
    let left = parseLogicalAndExpression();
    
    while (peek() === "||") {
      const op = consume();
      const right = parseLogicalAndExpression();
      left = { type: "BinaryExpression", op, left, right };
    }
    
    return left;
  }

  function parseLogicalAndExpression() {
    let left = parseComparisonExpression();
    
    while (peek() === "&&") {
      const op = consume();
      const right = parseComparisonExpression();
      left = { type: "BinaryExpression", op, left, right };
    }
    
    return left;
  }

  function parseComparisonExpression() {
    let left = parseAdditiveExpression();
    
    while (peek() === "<" || peek() === ">" || peek() === "<=" || peek() === ">=" || peek() === "==" || peek() === "!=") {
      const op = consume();
      const right = parseAdditiveExpression();
      left = { type: "BinaryExpression", op, left, right };
    }
    
    return left;
  }

  function parseAdditiveExpression() {
    let left = parseMultiplicativeExpression();
    
    while (peek() === "+" || peek() === "-") {
      const op = consume();
      const right = parseMultiplicativeExpression();
      left = { type: "BinaryExpression", op, left, right };
    }
    
    return left;
  }

  function parseMultiplicativeExpression() {
    let left = parsePrimaryExpression();
    
    while (peek() === "*" || peek() === "/" || peek() === "%") {
      const op = consume();
      const right = parsePrimaryExpression();
      left = { type: "BinaryExpression", op, left, right };
    }
    
    return left;
  }

  function parsePrimaryExpression() {
    const token = peek();
    
    // 字符串字面量
    // 检查是否包含中文双引号
    if (token.includes('“') || token.includes('”')) {
      throw new Error(`错误：检测到中文双引号，请使用英文双引号 """。字符串必须使用英文双引号包裹。`);
    }
    if (token.startsWith('"') && token.endsWith('"')) {
      return { type: "Literal", value: consume() };
    }
    
    // 数字字面量
    if (/^(?:\d+\.?\d*|\.\d+)$/.test(token)) {
      return { type: "Literal", value: consume() };
    }
    
    // 一元正负号和逻辑非
    if (token === "-" || token === "+" || token === "!") {
      const op = consume();
      const operand = parsePrimaryExpression();
      return { type: "UnaryExpression", op, operand };
    }
    
    // 变量标识符
    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(token)) {
      const name = consume();
      // 检查是否是数组访问
      if (peek() === "[") {
        consume("[");
        // 解析索引表达式，支持复杂表达式如 i+1, i*2+1 等
        const index = parseExpression();
        consume("]");
        return { type: "ArrayAccess", array: name, index };
      }
      return { type: "Identifier", name };
    }
    
    // 括号表达式
    if (token === "(") {
      consume("(");
      const expr = parseExpression();
      consume(")");
      return expr;
    }
    
    // 默认返回字面量
    return { type: "Literal", value: consume() };
  }


  /* 
  *解析语句
  *（for、if、return、代码块、表达式）
  */
  function parseStatement() {
    const t = peek();
    
    // 解析变量声明：int a = 200; 或 double a = 200; 或 int a; 或 int a,b,s; 或 int a[110]; 或 int a[],n;
    if ((t === "int" || t === "double") && peek(1) && /^[a-zA-Z_]\w*$/.test(peek(1))) {
      const dataType = consume();
      const declarations = []; // 存储所有声明（变量和数组）
      const declaredNames = new Set(); // 用于检查重复变量名
      
      // 收集所有声明
      let collecting = true;
      while (collecting) {
        const name = consume();
        
        // 检查变量名是否在同一语句中重复声明
        if (declaredNames.has(name)) {
          throw new Error(`错误：变量 '${name}' 在同一语句中重复定义。每个变量只能声明一次。`);
        }
        declaredNames.add(name);
        
        // 检查是否是数组声明
        if (peek() === "[") {
          consume("[");
          // 检查是否有数组大小
          let size = "0"; // 默认大小
          if (peek() !== "]") {
            size = consume();
          }
          consume("]");
          declarations.push({ type: "ArrayDeclaration", name, size, elements: null });
        } else {
          // 普通变量声明
          declarations.push({ type: "VariableDeclaration", name, dataType, valueTokens: null });
        }
        
        // 如果下一个token是逗号，继续收集
        if (peek() === ",") {
          consume(",");
          continue;
        }
        // 如果下一个token是分号，结束收集
        else if (peek() === ";") {
          consume(";");
          collecting = false;
        }
        // 如果下一个token是等号，处理初始化
        else if (peek() === "=") {
          consume("=");
          // 收集等号后的值，直到遇到逗号或分号
          const valueTokens = [];
          while (peek() !== "," && peek() !== ";") {
            valueTokens.push(consume());
          }
          // 更新当前声明为带初始化的变量声明
          if (declarations.length > 0) {
            const currentDecl = declarations[declarations.length - 1];
            if (currentDecl.type === "VariableDeclaration") {
              currentDecl.valueTokens = valueTokens;
            }
          }
          
          // 如果下一个token是逗号，继续处理下一个变量
          if (peek() === ",") {
            consume(",");
            continue;
          }
          // 如果下一个token是分号，结束收集
          else if (peek() === ";") {
            consume(";");
            collecting = false;
          }
        }
        else {
          throw new Error(`Unexpected token '${peek()}' in variable declaration`);
        }
      }
      
      // 如果只有一个声明，直接返回
      if (declarations.length === 1) {
        return declarations[0];
      }
      
      // 返回混合声明
      return { type: "MixedDeclaration", declarations };
    }
    
    //解析 for 循环语句
    if (t === "for") {
      consume("for");
      consume("(");    
      const init = [];   //init[]存储初始化条件
      while (peek() !== ";") init.push(consume());
      consume(";");
      
      // 检查for循环初始化的完整性
      if (init.length > 0) {
        // 检查是否是变量声明格式：int i = value 或 double i = value
        if ((init[0] === "int" || init[0] === "double") && init.length >= 4) {
          // 检查是否有等号
          const equalIndex = init.findIndex(token => token === "=");
          if (equalIndex === -1) {
            throw new Error(`错误：for循环初始化不完整。变量声明 '${init.join(' ')}' 缺少等号。请使用 'int ${init[1]} = 初始值;' 格式。`);
          }
          
          // 检查等号后是否有值
          if (equalIndex === init.length - 1) {
            throw new Error(`错误：for循环初始化不完整。变量声明 '${init.join(' ')}' 等号后缺少初始值。请提供初始值，如 'int ${init[1]} = 0;'。`);
          }
          
          // 检查等号前是否有变量名
          if (equalIndex < 2) {
            throw new Error(`错误：for循环初始化不完整。变量声明 '${init.join(' ')}' 缺少变量名。请使用 'int 变量名 = 初始值;' 格式。`);
          }
        } else if ((init[0] === "int" || init[0] === "double") && init.length < 4) {
          throw new Error(`错误：for循环初始化不完整。变量声明 '${init.join(' ')}' 格式不正确。请使用 'int 变量名 = 初始值;' 格式。`);
        }
        // 如果不是int声明，检查是否是赋值格式：i = value
        else if (init.length >= 3 && init[1] === "=") {
          if (init.length === 2) {
            throw new Error(`错误：for循环初始化不完整。赋值语句 '${init.join(' ')}' 等号后缺少值。请提供初始值，如 '${init[0]} = 0;'。`);
          }
        }
        // 如果是单个变量，检查是否是有效的变量名
        else if (init.length === 1) {
          if (!/^[a-zA-Z_]\w*$/.test(init[0])) {
            throw new Error(`错误：for循环初始化不完整。'${init[0]}' 不是有效的变量名。请使用 'int 变量名 = 初始值;' 或 '变量名 = 初始值;' 格式。`);
          }
        }
      }
      
      const cond = [];   //cond[]存储循环条件
      while (peek() !== ";") cond.push(consume());
      consume(";");
      
      // 如果条件为空，表示无限循环（如 for(;;) 或 for(int i=0;;i++)）
      // 不需要检查，允许空条件
      
      // 检查条件是否包含比较操作符（仅在条件不为空时检查）
      if (cond.length === 0) {
        // 空条件，跳过后续检查
      } else {
        const hasComparisonOp = cond.some(token => ["<", ">", "<=", ">=", "==", "!="].includes(token));
        if (!hasComparisonOp) {
          // 如果没有比较操作符，检查是否是单个变量或数字
          if (cond.length === 1 && (/^[a-zA-Z_]\w*$/.test(cond[0]) || /^\d+(\.\d+)?$/.test(cond[0]))) {
            // 单个变量或数字，这是有效的条件
          } else {
            throw new Error(`错误：for循环条件不完整。条件 '${cond.join(' ')}' 缺少比较操作符（如 <, >, <=, >=, ==, !=）。请提供完整的条件表达式。`);
          }
        } else {
          // 有比较操作符，检查操作符前后是否有操作数
          const opIndex = cond.findIndex(token => ["<", ">", "<=", ">=", "==", "!="].includes(token));
          if (opIndex === 0 || opIndex === cond.length - 1) {
            throw new Error(`错误：for循环条件不完整。比较操作符 '${cond[opIndex]}' 缺少操作数。请提供完整的条件表达式，如 'i < 10'。`);
          }
          
          // 检查操作符前后是否为空
          const leftTokens = cond.slice(0, opIndex);
          const rightTokens = cond.slice(opIndex + 1);
          if (leftTokens.length === 0 || rightTokens.length === 0) {
            throw new Error(`错误：for循环条件不完整。比较操作符 '${cond[opIndex]}' 前后缺少操作数。请提供完整的条件表达式，如 'i < 10'。`);
          }
        }
      }
      
      const incr = [];   //incr[]存储循环增量
      while (peek() !== ")") incr.push(consume());
      consume(")");
      
      // 检查for循环增量的完整性
      if (incr.length > 0) {
        // 检查是否是自增/自减操作：i++, i--, ++i, --i
        if (incr.length === 2) {
          if ((incr[0] === "++" || incr[0] === "--") && /^[a-zA-Z_]\w*$/.test(incr[1])) {
            // ++i 或 --i 格式，正确
          } else if (/^[a-zA-Z_]\w*$/.test(incr[0]) && (incr[1] === "++" || incr[1] === "--")) {
            // i++ 或 i-- 格式，正确
          } else if (/^[a-zA-Z_]\w*$/.test(incr[0]) && (incr[1] === "+" || incr[1] === "-")) {
            // 检查不完整的自增/自减：i+, i-
            throw new Error(`错误：for循环增量不完整。增量表达式 '${incr.join(' ')}' 缺少操作数。请使用 '${incr[0]}++', '${incr[0]}--', '++${incr[0]}', '--${incr[0]}' 或 '${incr[0]} += 值' 格式。`);
          } else {
            throw new Error(`错误：for循环增量不完整。增量表达式 '${incr.join(' ')}' 格式不正确。请使用 'i++', 'i--', '++i', '--i' 或 'i += 值' 格式。`);
          }
        }
        // 检查是否是复合赋值：i += value, i -= value 等
        else if (incr.length >= 3 && incr[1] === "+=") {
          if (incr.length === 2) {
            throw new Error(`错误：for循环增量不完整。复合赋值 '${incr.join(' ')}' 缺少值。请使用 '${incr[0]} += 值' 格式。`);
          }
        } else if (incr.length >= 3 && incr[1] === "-=") {
          if (incr.length === 2) {
            throw new Error(`错误：for循环增量不完整。复合赋值 '${incr.join(' ')}' 缺少值。请使用 '${incr[0]} -= 值' 格式。`);
          }
        }
        // 检查是否是简单赋值：i = i + 1
        else if (incr.length >= 5 && incr[1] === "=") {
          // 简单赋值格式，基本检查
        }
        // 检查单个操作符：+, -, ++, --
        else if (incr.length === 1 && ["+", "-", "++", "--"].includes(incr[0])) {
          throw new Error(`错误：for循环增量不完整。增量表达式 '${incr[0]}' 缺少变量。请使用 '变量名++', '变量名--', '++变量名', '--变量名' 或 '变量名 += 值' 格式。`);
        }
        // 检查单个变量（没有操作符）
        else if (incr.length === 1 && /^[a-zA-Z_]\w*$/.test(incr[0])) {
          throw new Error(`错误：for循环增量不完整。增量表达式 '${incr[0]}' 缺少操作符。请使用 '${incr[0]}++', '${incr[0]}--', '++${incr[0]}', '--${incr[0]}' 或 '${incr[0]} += 值' 格式。`);
        }
        // 其他不完整的情况
        else if (incr.length > 0) {
          throw new Error(`错误：for循环增量不完整。增量表达式 '${incr.join(' ')}' 格式不正确。请使用 'i++', 'i--', '++i', '--i' 或 'i += 值' 格式。`);
        }
      }
      
      const body = [parseStatement()];   //存储循环体
      
      // 调试信息：打印解析的for循环内容
      logger.log("=== For循环解析调试 ===");
      logger.log("init:", init);
      logger.log("cond:", cond);
      logger.log("incr:", incr);
      
      return { type: "ForStatement", init, cond, incr, body };
    } else if (t === "if") {
      //解析 if 判断语句
      consume("if");
      consume("(");
      const condition = parseExpression();
      consume(")");
      const body = [parseStatement()];
      //在 if 语句后检测 else，解析并存入 AST
      let elseBody = null;
      if (peek() === "else") {
        consume("else");
        elseBody = [parseStatement()];
      }
      
      // 调试信息
      logger.log("=== If语句解析调试 ===");
      logger.log("condition:", condition);
      logger.log("body:", body);
      logger.log("elseBody:", elseBody);
      
      return { type: "IfStatement", condition, body, elseBody };
    } else if (t === "return") {
      //解析 return 语句
      consume("return");
      const value = parseExpression();
      consume(";");
      return { type: "ReturnStatement", value };
    } else if (t === "break") {
      //解析 break 语句
      consume("break");
      consume(";");
      return { type: "BreakStatement" };
    } else if (t === "continue") {
      //解析 continue 语句
      consume("continue");
      consume(";");
      return { type: "ContinueStatement" };
    } else if (t === "wait") {
      // 解析 wait 语句
      consume("wait");
      consume("(");
      const value = parseExpression();
      consume(")");
      consume(";");
      return { type: "WaitStatement", value };
    } else if (t === "cin") {
      // 解析 cin 语句
      consume("cin");
      const variables = [];
      while (peek() === ">>") {
        consume(">>");
        
        // 检查是否是数组元素 (如 a[i])
        if (peek() !== ";" && peek() !== ">>") {
          const varName = consume(); // 获取变量名
          if (peek() === "[") {
            // 处理数组元素
            consume("["); // 消费 [
            const index = consume(); // 获取索引
            consume("]"); // 消费 ]
            variables.push(`${varName}[${index}]`);
          } else {
            // 普通变量
            variables.push(varName);
          }
        }
      }
      consume(";");
      return { type: "CinStatement", variables };
    } else if (t === "cinWin") {
      // 解析 cinWin() 语句
      consume("cinWin");
      consume("(");
      consume(")");
      consume(";");
      return { type: "CinWinStatement" };
    } else if (t === "cout") {
      // 解析 cout 语句
      consume("cout");
      const expressions = [];
      while (peek() === "<<") {
        consume("<<");
        // 解析表达式（可能是变量、字符串、数字或操作符）
        if (peek() === "endl") {
          consume("endl");
          expressions.push({ type: "endl" });
        } else if (peek() === "setprecision") {
          consume("setprecision");
          consume("(");
          const precision = consume();
          consume(")");
          expressions.push({ type: "setprecision", value: precision });
        } else if (peek() === "fixed") {
          consume("fixed");
          expressions.push({ type: "fixed" });
        } else if (peek() === "scientific") {
          consume("scientific");
          expressions.push({ type: "scientific" });
        } else if (peek() === "defaultfloat") {
          consume("defaultfloat");
          expressions.push({ type: "defaultfloat" });
        } else {
          // 解析普通表达式
          const expr = parseExpression();
          expressions.push(expr);
        }
      }
      consume(";");
      return { type: "CoutStatement", expressions };
    } else if (t === "{") {
      //解析用 {} 包裹的代码块
      consume("{");
      const body = []; 
      while (peek() !== "}") body.push(parseStatement());
      consume("}");
      return { type: "BlockStatement", body };
    } else {
      //解析普通的表达式语句（如 pen.fd(100).rt(90);）
      const parts = [];
      while (peek() && peek() !== ";") {
        parts.push(consume());
      }
      
      // 检查是否是pen命令，如果是则强制要求分号
      if (parts.length > 0 && parts[0] === "pen") {
        if (peek() !== ";") {
          throw new Error(`pen命令后必须加分号，但发现 '${peek()}'`);
        }
      }
      
      // 检查pen命令是否缺少括号
      if (parts.length >= 2 && (parts[0] === "pen" || parts[0] === "p") && parts[1] !== ".") {
        const prefix = parts[0];
        throw new Error(`语法错误：pen命令后必须使用点号(.)连接，不能直接使用 '${prefix}${parts[1]}'。请使用 '${prefix}.方法名()' 而不是 '${prefix}方法名'。`);
      }
      
      // 检查pen命令是否缺少括号（如 pen.fd; 或 p.fd;）
      if (parts.length >= 3 && (parts[0] === "pen" || parts[0] === "p") && parts[1] === ".") {
        const commandName = parts[2];
        const prefix = parts[0];
        // 检查是否包含左括号
        const hasLeftParen = parts.includes("(");
        if (!hasLeftParen) {
          throw new Error(`语法错误：pen命令 '${prefix}.${commandName}' 缺少括号。请使用 '${prefix}.${commandName}()' 而不是 '${prefix}.${commandName}'。`);
        }
      }
      
      consume(";");
      
      // 检测数组赋值：arr[0] = 10; 或 arr[0] = arr[1];
      if (parts.length >= 5 && parts[1] === "[" && parts[3] === "]" && parts[4] === "=") {
        const arrayName = parts[0];
        const index = parts[2];
        const value = parts.slice(5);
        
        // 检查赋值源是否是数组访问：arr[i] = arr[j];
        if (value.length >= 3 && value[1] === "[" && value[3] === "]") {
          return { 
            type: "ArrayAssignment", 
            array: arrayName, 
            index, 
            value: { 
              type: "ArrayAccess", 
              array: value[0], 
              index: value[2] 
            } 
          };
        }
        
        return { type: "ArrayAssignment", array: arrayName, index, value };
      }
      
      // 检测简单变量赋值：t = 1; 或 t = n+1;
      if (parts.length >= 3 && parts[1] === "=") {
        const varName = parts[0];
        const valueTokens = parts.slice(2);
        return { type: "VariableAssignment", name: varName, valueTokens };
      }
      
      // 处理表达式语句，正确解析括号内的运算
      const processedParts = [];
      let i = 0;
      while (i < parts.length) {
        // 检测数组访问：arr[expr] - 支持复杂表达式
        if (i + 1 < parts.length && parts[i + 1] === "[") {
          const arrayName = parts[i];
          i += 2; // 跳过数组名和左括号
          
          // 收集方括号内的tokens
          const indexTokens = [];
          let depth = 1;
          while (i < parts.length && depth > 0) {
            if (parts[i] === "[") depth++;
            else if (parts[i] === "]") depth--;
            if (depth > 0) indexTokens.push(parts[i]);
            i++;
          }
          
          // 解析索引表达式
          if (indexTokens.length > 0) {
            // 临时保存当前状态
            const originalPos = pos;
            const originalTokens = tokens;
            
            // 创建新的tokens数组用于解析索引表达式
            tokens = indexTokens;
            pos = 0;
            
            try {
              const indexExpression = parseExpression();
              processedParts.push({ type: "ArrayAccess", array: arrayName, index: indexExpression });
            } catch (error) {
              // 如果解析失败，回退到简单处理
              processedParts.push({ type: "ArrayAccess", array: arrayName, index: { type: "Literal", value: indexTokens.join(' ') } });
            }
            
            // 恢复原始状态
            tokens = originalTokens;
            pos = originalPos;
          } else {
            processedParts.push({ type: "ArrayAccess", array: arrayName, index: { type: "Literal", value: "0" } });
          }
        }
        // 检测函数调用：func(expr)
        else if (i + 1 < parts.length && parts[i + 1] === "(") {
          const funcName = parts[i];
          i += 2; // 跳过函数名和左括号
          
          // 收集括号内的tokens
          const argTokens = [];
          let depth = 1;
          while (i < parts.length && depth > 0) {
            if (parts[i] === "(") depth++;
            else if (parts[i] === ")") depth--;
            if (depth > 0) argTokens.push(parts[i]);
            i++;
          }
          
          // 解析括号内的多个参数（用逗号分隔）
          if (argTokens.length > 0) {
            // 临时保存当前pos，用于解析参数表达式
            const originalPos = pos;
            const originalTokens = tokens;
            
            // 创建新的tokens数组用于解析参数
            tokens = argTokens;
            pos = 0;
            
            try {
              // 解析多个参数，用逗号分隔
              const args = [];
              let depth = 0;
              let currentArgTokens = [];
              
              for (let k = 0; k < argTokens.length; k++) {
                const token = argTokens[k];
                
                if (token === '(') {
                  depth++;
                  currentArgTokens.push(token);
                } else if (token === ')') {
                  depth--;
                  currentArgTokens.push(token);
                } else if (token === ',' && depth === 0) {
                  // 顶层逗号，分隔参数
                  if (currentArgTokens.length > 0) {
                    // 解析当前参数
                    const tempTokens = tokens;
                    const tempPos = pos;
                    tokens = currentArgTokens;
                    pos = 0;
                    
                    try {
                      const argExpression = parseExpression();
                      args.push(argExpression);
                    } catch (error) {
                      // 如果解析失败，回退到简单处理
                      args.push({ type: "Literal", value: currentArgTokens.join(' ') });
                    }
                    
                    tokens = tempTokens;
                    pos = tempPos;
                  }
                  currentArgTokens = [];
                } else {
                  currentArgTokens.push(token);
                }
              }
              
              // 处理最后一个参数
              if (currentArgTokens.length > 0) {
                const tempTokens = tokens;
                const tempPos = pos;
                tokens = currentArgTokens;
                pos = 0;
                
                try {
                  const argExpression = parseExpression();
                  args.push(argExpression);
                } catch (error) {
                  // 如果解析失败，回退到简单处理
                  args.push({ type: "Literal", value: currentArgTokens.join(' ') });
                }
                
                tokens = tempTokens;
                pos = tempPos;
              }
              
              processedParts.push({ type: "FunctionCall", name: funcName, args });
            } catch (error) {
              // 如果解析失败，回退到简单处理
              processedParts.push({ type: "FunctionCall", name: funcName, args: argTokens });
            }
            
            // 恢复原始状态
            tokens = originalTokens;
            pos = originalPos;
          } else {
            processedParts.push({ type: "FunctionCall", name: funcName, args: [] });
          }
        }
        else {
          processedParts.push(parts[i]);
          i++;
        }
      }
      
      return { type: "ExpressionStatement", expression: processedParts };
    }
  }


  /* 
  *phaser 入口函数
  *解析主函数体，支持全局变量声明
  */
  function parseProgram() {
    const body = [];
    
    // 调试信息：打印当前token
    logger.log("Parsing program, current token:", peek());
    
    // 解析全局变量声明和main函数
    while (peek() && peek() !== undefined) {
      const currentToken = peek();
      
      // 检查是否是全局变量声明
      if ((currentToken === "int" || currentToken === "double") && peek(1) && peek(1) !== "main") {
        // 解析全局变量声明
        const globalVar = parseStatement();
        body.push(globalVar);
        logger.log("解析到全局变量声明:", globalVar);
      }
      // 检查是否是main函数
      else if (currentToken === "int" && peek(1) === "main") {
        consume("int");
        consume("main");
        consume("(");
        consume(")");
        
        // 检查是否有花括号包围的代码块
        if (peek() === "{") {
          const mainBody = parseStatement(); // 这会解析BlockStatement
          body.push(mainBody);
          logger.log("解析到main函数:", mainBody);
        } else {
          const mainBody = parseStatement();
          body.push(mainBody);
          logger.log("解析到main函数:", mainBody);
        }
        break; // main函数解析完成后退出
      }
      // 其他语句
      else {
        const stmt = parseStatement();
        body.push(stmt);
        logger.log("解析到其他语句:", stmt);
      }
    }
    
    return { type: "Program", body };
  }

  return parseProgram();
}

export { parse }